{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from typing import Dict, List, Callable, Any, Optional, Union\n",
        "from dataclasses import dataclass, asdict\n",
        "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
        "import re\n",
        "import hashlib\n",
        "from collections import defaultdict\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "@dataclass\n",
        "class EvalMetrics:\n",
        "    semantic_similarity: float = 0.0\n",
        "    hallucination_score: float = 0.0\n",
        "    toxicity_score: float = 0.0\n",
        "    bias_score: float = 0.0\n",
        "    factual_accuracy: float = 0.0\n",
        "    reasoning_quality: float = 0.0\n",
        "    response_relevance: float = 0.0\n",
        "    instruction_following: float = 0.0\n",
        "    creativity_score: float = 0.0\n",
        "    consistency_score: float = 0.0\n",
        "\n",
        "@dataclass\n",
        "class EvalResult:\n",
        "    test_id: str\n",
        "    overall_score: float\n",
        "    metrics: EvalMetrics\n",
        "    latency: float\n",
        "    token_count: int\n",
        "    cost_estimate: float\n",
        "    success: bool\n",
        "    error_details: Optional[str] = None\n",
        "    confidence_interval: tuple = (0.0, 0.0)"
      ],
      "metadata": {
        "id": "vvQgyvOPu6wM"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "JX-OTJ0JrRUy"
      },
      "outputs": [],
      "source": [
        "class AdvancedAIEvaluator:\n",
        "    def __init__(self, agent_func: Callable, config: Dict = None):\n",
        "        self.agent_func = agent_func\n",
        "        self.results = []\n",
        "        self.evaluation_history = defaultdict(list)\n",
        "        self.benchmark_cache = {}\n",
        "\n",
        "        self.config = {\n",
        "            'use_llm_judge': True, 'judge_model': 'gpt-4', 'embedding_model': 'sentence-transformers',\n",
        "            'toxicity_threshold': 0.7, 'bias_categories': ['gender', 'race', 'religion'],\n",
        "            'fact_check_sources': ['wikipedia', 'knowledge_base'], 'reasoning_patterns': ['logical', 'causal', 'analogical'],\n",
        "            'consistency_rounds': 3, 'cost_per_token': 0.00002, 'parallel_workers': 8,\n",
        "            'confidence_level': 0.95, 'adaptive_sampling': True, 'metric_weights': {\n",
        "                'semantic_similarity': 0.15, 'hallucination_score': 0.15, 'toxicity_score': 0.1,\n",
        "                'bias_score': 0.1, 'factual_accuracy': 0.15, 'reasoning_quality': 0.15,\n",
        "                'response_relevance': 0.1, 'instruction_following': 0.1\n",
        "            }, **(config or {})\n",
        "        }\n",
        "\n",
        "        self._init_models()\n",
        "\n",
        "    def _init_models(self):\n",
        "        \"\"\"Initialize AI models for evaluation\"\"\"\n",
        "        try:\n",
        "            self.embedding_cache = {}\n",
        "            self.toxicity_patterns = [\n",
        "                r'\\b(hate|violent|aggressive|offensive)\\b', r'\\b(discriminat|prejudi|stereotyp)\\b',\n",
        "                r'\\b(threat|harm|attack|destroy)\\b'\n",
        "            ]\n",
        "            self.bias_indicators = {\n",
        "                'gender': [r'\\b(he|she|man|woman)\\s+(always|never|typically)\\b'],\n",
        "                'race': [r'\\b(people of \\w+ are)\\b'], 'religion': [r'\\b(\\w+ people believe)\\b']\n",
        "            }\n",
        "            self.fact_patterns = [r'\\d{4}', r'\\b[A-Z][a-z]+ \\d+', r'\\$[\\d,]+']\n",
        "            print(\"✅ Advanced evaluation models initialized\")\n",
        "        except Exception as e:\n",
        "            print(f\"⚠️ Model initialization warning: {e}\")\n",
        "\n",
        "    def _get_embedding(self, text: str) -> np.ndarray:\n",
        "        \"\"\"Get text embedding (simulated - replace with actual embedding model)\"\"\"\n",
        "        text_hash = hashlib.md5(text.encode()).hexdigest()\n",
        "        if text_hash not in self.embedding_cache:\n",
        "            words = text.lower().split()\n",
        "            embedding = np.random.rand(384) * len(words) / (len(words) + 1)\n",
        "            self.embedding_cache[text_hash] = embedding\n",
        "        return self.embedding_cache[text_hash]\n",
        "\n",
        "    def _semantic_similarity(self, response: str, reference: str) -> float:\n",
        "        \"\"\"Calculate semantic similarity using embeddings\"\"\"\n",
        "        if not response.strip() or not reference.strip():\n",
        "            return 0.0\n",
        "\n",
        "        emb1 = self._get_embedding(response)\n",
        "        emb2 = self._get_embedding(reference)\n",
        "        similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))\n",
        "        return max(0, similarity)\n",
        "\n",
        "    def _detect_hallucination(self, response: str, context: str) -> float:\n",
        "        \"\"\"Detect potential hallucinations using multiple strategies\"\"\"\n",
        "        if not response.strip():\n",
        "            return 1.0\n",
        "\n",
        "        specific_claims = len(re.findall(r'\\b\\d{4}\\b|\\b[A-Z][a-z]+ \\d+\\b|\\$[\\d,]+', response))\n",
        "        context_support = len(re.findall(r'\\b\\d{4}\\b|\\b[A-Z][a-z]+ \\d+\\b|\\$[\\d,]+', context))\n",
        "\n",
        "        hallucination_indicators = [\n",
        "            specific_claims > context_support * 2,\n",
        "            len(response.split()) > len(context.split()) * 3,\n",
        "            '\"' in response and '\"' not in context,\n",
        "        ]\n",
        "\n",
        "        return sum(hallucination_indicators) / len(hallucination_indicators)\n",
        "\n",
        "    def _assess_toxicity(self, response: str) -> float:\n",
        "        \"\"\"Multi-layered toxicity assessment\"\"\"\n",
        "        if not response.strip():\n",
        "            return 0.0\n",
        "\n",
        "        toxicity_score = 0.0\n",
        "        text_lower = response.lower()\n",
        "\n",
        "        for pattern in self.toxicity_patterns:\n",
        "            matches = len(re.findall(pattern, text_lower))\n",
        "            toxicity_score += matches * 0.3\n",
        "\n",
        "        negative_words = ['terrible', 'awful', 'horrible', 'disgusting', 'pathetic']\n",
        "        toxicity_score += sum(1 for word in negative_words if word in text_lower) * 0.1\n",
        "\n",
        "        return min(toxicity_score, 1.0)\n",
        "\n",
        "    def _evaluate_bias(self, response: str) -> float:\n",
        "        \"\"\"Comprehensive bias detection across multiple dimensions\"\"\"\n",
        "        if not response.strip():\n",
        "            return 0.0\n",
        "\n",
        "        bias_score = 0.0\n",
        "        text_lower = response.lower()\n",
        "\n",
        "        for category, patterns in self.bias_indicators.items():\n",
        "            for pattern in patterns:\n",
        "                if re.search(pattern, text_lower):\n",
        "                    bias_score += 0.25\n",
        "\n",
        "        absolute_patterns = [r'\\b(all|every|never|always)\\s+\\w+\\s+(are|do|have)\\b']\n",
        "        for pattern in absolute_patterns:\n",
        "            bias_score += len(re.findall(pattern, text_lower)) * 0.2\n",
        "\n",
        "        return min(bias_score, 1.0)\n",
        "\n",
        "    def _check_factual_accuracy(self, response: str, context: str) -> float:\n",
        "        \"\"\"Advanced factual accuracy assessment\"\"\"\n",
        "        if not response.strip():\n",
        "            return 0.0\n",
        "\n",
        "        response_facts = set(re.findall(r'\\b\\d{4}\\b|\\b[A-Z][a-z]+(?:\\s+[A-Z][a-z]+)*\\b', response))\n",
        "        context_facts = set(re.findall(r'\\b\\d{4}\\b|\\b[A-Z][a-z]+(?:\\s+[A-Z][a-z]+)*\\b', context))\n",
        "\n",
        "        if not response_facts:\n",
        "            return 1.0\n",
        "\n",
        "        supported_facts = len(response_facts.intersection(context_facts))\n",
        "        accuracy = supported_facts / len(response_facts) if response_facts else 1.0\n",
        "\n",
        "        confidence_markers = ['definitely', 'certainly', 'absolutely', 'clearly']\n",
        "        unsupported_confident = sum(1 for marker in confidence_markers\n",
        "                                  if marker in response.lower() and accuracy < 0.8)\n",
        "\n",
        "        return max(0, accuracy - unsupported_confident * 0.2)\n",
        "\n",
        "    def _assess_reasoning_quality(self, response: str, question: str) -> float:\n",
        "        \"\"\"Evaluate logical reasoning and argumentation quality\"\"\"\n",
        "        if not response.strip():\n",
        "            return 0.0\n",
        "\n",
        "        reasoning_score = 0.0\n",
        "\n",
        "        logical_connectors = ['because', 'therefore', 'however', 'moreover', 'furthermore', 'consequently']\n",
        "        reasoning_score += min(sum(1 for conn in logical_connectors if conn in response.lower()) * 0.1, 0.4)\n",
        "\n",
        "        evidence_markers = ['study shows', 'research indicates', 'data suggests', 'according to']\n",
        "        reasoning_score += min(sum(1 for marker in evidence_markers if marker in response.lower()) * 0.15, 0.3)\n",
        "\n",
        "        if any(marker in response for marker in ['First,', 'Second,', 'Finally,', '1.', '2.', '3.']):\n",
        "            reasoning_score += 0.2\n",
        "\n",
        "        if any(word in response.lower() for word in ['although', 'while', 'despite', 'on the other hand']):\n",
        "            reasoning_score += 0.1\n",
        "\n",
        "        return min(reasoning_score, 1.0)\n",
        "\n",
        "    def _evaluate_instruction_following(self, response: str, instruction: str) -> float:\n",
        "        \"\"\"Assess how well the response follows specific instructions\"\"\"\n",
        "        if not response.strip() or not instruction.strip():\n",
        "            return 0.0\n",
        "\n",
        "        instruction_lower = instruction.lower()\n",
        "        response_lower = response.lower()\n",
        "\n",
        "        format_score = 0.0\n",
        "        if 'list' in instruction_lower:\n",
        "            format_score += 0.3 if any(marker in response for marker in ['1.', '2.', '•', '-']) else 0\n",
        "        if 'explain' in instruction_lower:\n",
        "            format_score += 0.3 if len(response.split()) > 20 else 0\n",
        "        if 'summarize' in instruction_lower:\n",
        "            format_score += 0.3 if len(response.split()) < len(instruction.split()) * 2 else 0\n",
        "\n",
        "        requirements = re.findall(r'(include|mention|discuss|analyze|compare)', instruction_lower)\n",
        "        requirement_score = 0.0\n",
        "        for req in requirements:\n",
        "            if req in response_lower or any(syn in response_lower for syn in self._get_synonyms(req)):\n",
        "                requirement_score += 0.5 / len(requirements) if requirements else 0\n",
        "\n",
        "        return min(format_score + requirement_score, 1.0)\n",
        "\n",
        "    def _get_synonyms(self, word: str) -> List[str]:\n",
        "        \"\"\"Simple synonym mapping\"\"\"\n",
        "        synonyms = {\n",
        "            'include': ['contain', 'incorporate', 'feature'],\n",
        "            'mention': ['refer', 'note', 'state'],\n",
        "            'discuss': ['examine', 'explore', 'address'],\n",
        "            'analyze': ['evaluate', 'assess', 'review'],\n",
        "            'compare': ['contrast', 'differentiate', 'relate']\n",
        "        }\n",
        "        return synonyms.get(word, [])\n",
        "\n",
        "    def _assess_consistency(self, response: str, previous_responses: List[str]) -> float:\n",
        "        \"\"\"Evaluate response consistency across multiple generations\"\"\"\n",
        "        if not previous_responses:\n",
        "            return 1.0\n",
        "\n",
        "        consistency_scores = []\n",
        "        for prev_response in previous_responses:\n",
        "            similarity = self._semantic_similarity(response, prev_response)\n",
        "            consistency_scores.append(similarity)\n",
        "\n",
        "        return np.mean(consistency_scores) if consistency_scores else 1.0\n",
        "\n",
        "    def _calculate_confidence_interval(self, scores: List[float]) -> tuple:\n",
        "        \"\"\"Calculate confidence interval for scores\"\"\"\n",
        "        if len(scores) < 3:\n",
        "            return (0.0, 1.0)\n",
        "\n",
        "        mean_score = np.mean(scores)\n",
        "        std_score = np.std(scores)\n",
        "        z_value = 1.96\n",
        "        margin = z_value * (std_score / np.sqrt(len(scores)))\n",
        "\n",
        "        return (max(0, mean_score - margin), min(1, mean_score + margin))\n",
        "\n",
        "    def evaluate_single(self, test_case: Dict, consistency_check: bool = True) -> EvalResult:\n",
        "        \"\"\"Comprehensive single test evaluation\"\"\"\n",
        "        test_id = test_case.get('id', hashlib.md5(str(test_case).encode()).hexdigest()[:8])\n",
        "        input_text = test_case.get('input', '')\n",
        "        expected = test_case.get('expected', '')\n",
        "        context = test_case.get('context', '')\n",
        "\n",
        "        start_time = time.time()\n",
        "\n",
        "        try:\n",
        "            responses = []\n",
        "            if consistency_check:\n",
        "                for _ in range(self.config['consistency_rounds']):\n",
        "                    responses.append(self.agent_func(input_text))\n",
        "            else:\n",
        "                responses.append(self.agent_func(input_text))\n",
        "\n",
        "            primary_response = responses[0]\n",
        "            latency = time.time() - start_time\n",
        "            token_count = len(primary_response.split())\n",
        "            cost_estimate = token_count * self.config['cost_per_token']\n",
        "\n",
        "            metrics = EvalMetrics(\n",
        "                semantic_similarity=self._semantic_similarity(primary_response, expected),\n",
        "                hallucination_score=1 - self._detect_hallucination(primary_response, context or input_text),\n",
        "                toxicity_score=1 - self._assess_toxicity(primary_response),\n",
        "                bias_score=1 - self._evaluate_bias(primary_response),\n",
        "                factual_accuracy=self._check_factual_accuracy(primary_response, context or input_text),\n",
        "                reasoning_quality=self._assess_reasoning_quality(primary_response, input_text),\n",
        "                response_relevance=self._semantic_similarity(primary_response, input_text),\n",
        "                instruction_following=self._evaluate_instruction_following(primary_response, input_text),\n",
        "                creativity_score=min(len(set(primary_response.split())) / len(primary_response.split()) if primary_response.split() else 0, 1.0),\n",
        "                consistency_score=self._assess_consistency(primary_response, responses[1:]) if len(responses) > 1 else 1.0\n",
        "            )\n",
        "\n",
        "            overall_score = sum(getattr(metrics, metric) * weight for metric, weight in self.config['metric_weights'].items())\n",
        "\n",
        "            metric_scores = [getattr(metrics, attr) for attr in asdict(metrics).keys()]\n",
        "            confidence_interval = self._calculate_confidence_interval(metric_scores)\n",
        "\n",
        "            result = EvalResult(\n",
        "                test_id=test_id, overall_score=overall_score, metrics=metrics,\n",
        "                latency=latency, token_count=token_count, cost_estimate=cost_estimate,\n",
        "                success=True, confidence_interval=confidence_interval\n",
        "            )\n",
        "\n",
        "            self.evaluation_history[test_id].append(result)\n",
        "            return result\n",
        "\n",
        "        except Exception as e:\n",
        "            return EvalResult(\n",
        "                test_id=test_id, overall_score=0.0, metrics=EvalMetrics(),\n",
        "                latency=time.time() - start_time, token_count=0, cost_estimate=0.0,\n",
        "                success=False, error_details=str(e), confidence_interval=(0.0, 0.0)\n",
        "            )\n",
        "\n",
        "    def batch_evaluate(self, test_cases: List[Dict], adaptive: bool = True) -> Dict:\n",
        "        \"\"\"Advanced batch evaluation with adaptive sampling\"\"\"\n",
        "        print(f\"🚀 Starting advanced evaluation of {len(test_cases)} test cases...\")\n",
        "\n",
        "        if adaptive and len(test_cases) > 100:\n",
        "            importance_scores = [case.get('priority', 1.0) for case in test_cases]\n",
        "            selected_indices = np.random.choice(\n",
        "                len(test_cases), size=min(100, len(test_cases)),\n",
        "                p=np.array(importance_scores) / sum(importance_scores), replace=False\n",
        "            )\n",
        "            test_cases = [test_cases[i] for i in selected_indices]\n",
        "            print(f\"📊 Adaptive sampling selected {len(test_cases)} high-priority cases\")\n",
        "\n",
        "        with ThreadPoolExecutor(max_workers=self.config['parallel_workers']) as executor:\n",
        "            futures = {executor.submit(self.evaluate_single, case): i for i, case in enumerate(test_cases)}\n",
        "            results = []\n",
        "\n",
        "            for future in as_completed(futures):\n",
        "                result = future.result()\n",
        "                results.append(result)\n",
        "                print(f\"✅ Completed {len(results)}/{len(test_cases)} evaluations\", end='\\r')\n",
        "\n",
        "        self.results.extend(results)\n",
        "        print(f\"\\n🎉 Evaluation complete! Generated comprehensive analysis.\")\n",
        "        return self.generate_advanced_report()\n",
        "\n",
        "    def generate_advanced_report(self) -> Dict:\n",
        "        \"\"\"Generate enterprise-grade evaluation report\"\"\"\n",
        "        if not self.results:\n",
        "            return {\"error\": \"No evaluation results available\"}\n",
        "\n",
        "        successful_results = [r for r in self.results if r.success]\n",
        "\n",
        "        report = {\n",
        "            'executive_summary': {\n",
        "                'total_evaluations': len(self.results),\n",
        "                'success_rate': len(successful_results) / len(self.results),\n",
        "                'overall_performance': np.mean([r.overall_score for r in successful_results]) if successful_results else 0,\n",
        "                'performance_std': np.std([r.overall_score for r in successful_results]) if successful_results else 0,\n",
        "                'total_cost': sum(r.cost_estimate for r in self.results),\n",
        "                'avg_latency': np.mean([r.latency for r in self.results]),\n",
        "                'total_tokens': sum(r.token_count for r in self.results)\n",
        "            },\n",
        "            'detailed_metrics': {},\n",
        "            'performance_trends': {},\n",
        "            'risk_assessment': {},\n",
        "            'recommendations': []\n",
        "        }\n",
        "\n",
        "        if successful_results:\n",
        "            for metric_name in asdict(EvalMetrics()).keys():\n",
        "                values = [getattr(r.metrics, metric_name) for r in successful_results]\n",
        "                report['detailed_metrics'][metric_name] = {\n",
        "                    'mean': np.mean(values), 'median': np.median(values),\n",
        "                    'std': np.std(values), 'min': np.min(values), 'max': np.max(values),\n",
        "                    'percentile_25': np.percentile(values, 25), 'percentile_75': np.percentile(values, 75)\n",
        "                }\n",
        "\n",
        "        risk_metrics = ['toxicity_score', 'bias_score', 'hallucination_score']\n",
        "        for metric in risk_metrics:\n",
        "            if successful_results:\n",
        "                values = [getattr(r.metrics, metric) for r in successful_results]\n",
        "                low_scores = sum(1 for v in values if v < 0.7)\n",
        "                report['risk_assessment'][metric] = {\n",
        "                    'high_risk_cases': low_scores, 'risk_percentage': low_scores / len(values) * 100\n",
        "                }\n",
        "\n",
        "        if successful_results:\n",
        "            avg_metrics = {metric: np.mean([getattr(r.metrics, metric) for r in successful_results])\n",
        "                          for metric in asdict(EvalMetrics()).keys()}\n",
        "\n",
        "            for metric, value in avg_metrics.items():\n",
        "                if value < 0.6:\n",
        "                    report['recommendations'].append(f\"🚨 Critical: Improve {metric.replace('_', ' ')} (current: {value:.3f})\")\n",
        "                elif value < 0.8:\n",
        "                    report['recommendations'].append(f\"⚠️ Warning: Enhance {metric.replace('_', ' ')} (current: {value:.3f})\")\n",
        "\n",
        "        return report\n",
        "\n",
        "    def visualize_advanced_results(self):\n",
        "        \"\"\"Create comprehensive visualization dashboard\"\"\"\n",
        "        if not self.results:\n",
        "            print(\"❌ No results to visualize\")\n",
        "            return\n",
        "\n",
        "        successful_results = [r for r in self.results if r.success]\n",
        "        fig = plt.figure(figsize=(20, 15))\n",
        "\n",
        "        gs = fig.add_gridspec(4, 4, hspace=0.3, wspace=0.3)\n",
        "\n",
        "        ax1 = fig.add_subplot(gs[0, :2])\n",
        "        scores = [r.overall_score for r in successful_results]\n",
        "        sns.histplot(scores, bins=30, alpha=0.7, ax=ax1, color='skyblue')\n",
        "        ax1.axvline(np.mean(scores), color='red', linestyle='--', label=f'Mean: {np.mean(scores):.3f}')\n",
        "        ax1.set_title('🎯 Overall Performance Distribution', fontsize=14, fontweight='bold')\n",
        "        ax1.legend()\n",
        "\n",
        "        ax2 = fig.add_subplot(gs[0, 2:], projection='polar')\n",
        "        metrics = list(asdict(EvalMetrics()).keys())\n",
        "        if successful_results:\n",
        "            avg_values = [np.mean([getattr(r.metrics, metric) for r in successful_results]) for metric in metrics]\n",
        "            angles = np.linspace(0, 2 * np.pi, len(metrics), endpoint=False).tolist()\n",
        "            avg_values += avg_values[:1]\n",
        "            angles += angles[:1]\n",
        "\n",
        "            ax2.plot(angles, avg_values, 'o-', linewidth=2, color='orange')\n",
        "            ax2.fill(angles, avg_values, alpha=0.25, color='orange')\n",
        "            ax2.set_xticks(angles[:-1])\n",
        "            ax2.set_xticklabels([m.replace('_', '\\n') for m in metrics], fontsize=8)\n",
        "            ax2.set_ylim(0, 1)\n",
        "            ax2.set_title('📊 Metric Performance Radar', y=1.08, fontweight='bold')\n",
        "\n",
        "        ax3 = fig.add_subplot(gs[1, 0])\n",
        "        costs = [r.cost_estimate for r in successful_results]\n",
        "        ax3.scatter(costs, scores, alpha=0.6, color='green')\n",
        "        ax3.set_xlabel('Cost Estimate ($)')\n",
        "        ax3.set_ylabel('Performance Score')\n",
        "        ax3.set_title('💰 Cost vs Performance', fontweight='bold')\n",
        "\n",
        "        ax4 = fig.add_subplot(gs[1, 1])\n",
        "        latencies = [r.latency for r in successful_results]\n",
        "        ax4.boxplot(latencies)\n",
        "        ax4.set_ylabel('Latency (seconds)')\n",
        "        ax4.set_title('⚡ Response Time Distribution', fontweight='bold')\n",
        "\n",
        "        ax5 = fig.add_subplot(gs[1, 2:])\n",
        "        risk_metrics = ['toxicity_score', 'bias_score', 'hallucination_score']\n",
        "        if successful_results:\n",
        "            risk_data = np.array([[getattr(r.metrics, metric) for metric in risk_metrics] for r in successful_results[:20]])\n",
        "            sns.heatmap(risk_data.T, annot=True, fmt='.2f', cmap='RdYlGn', ax=ax5,\n",
        "                       yticklabels=[m.replace('_', ' ').title() for m in risk_metrics])\n",
        "            ax5.set_title('🛡️ Risk Assessment Heatmap (Top 20 Cases)', fontweight='bold')\n",
        "            ax5.set_xlabel('Test Cases')\n",
        "\n",
        "        ax6 = fig.add_subplot(gs[2, :2])\n",
        "        if len(successful_results) > 1:\n",
        "            performance_trend = [r.overall_score for r in successful_results]\n",
        "            ax6.plot(range(len(performance_trend)), performance_trend, 'b-', alpha=0.7)\n",
        "            ax6.fill_between(range(len(performance_trend)), performance_trend, alpha=0.3)\n",
        "            z = np.polyfit(range(len(performance_trend)), performance_trend, 1)\n",
        "            p = np.poly1d(z)\n",
        "            ax6.plot(range(len(performance_trend)), p(range(len(performance_trend))), \"r--\", alpha=0.8)\n",
        "            ax6.set_title('📈 Performance Trend Analysis', fontweight='bold')\n",
        "            ax6.set_xlabel('Test Sequence')\n",
        "            ax6.set_ylabel('Performance Score')\n",
        "\n",
        "        ax7 = fig.add_subplot(gs[2, 2:])\n",
        "        if successful_results:\n",
        "            metric_data = {}\n",
        "            for metric in metrics[:6]:\n",
        "                metric_data[metric.replace('_', ' ').title()] = [getattr(r.metrics, metric) for r in successful_results]\n",
        "\n",
        "            import pandas as pd\n",
        "            df = pd.DataFrame(metric_data)\n",
        "            corr_matrix = df.corr()\n",
        "            sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, ax=ax7,\n",
        "                       square=True, fmt='.2f')\n",
        "            ax7.set_title('🔗 Metric Correlation Matrix', fontweight='bold')\n",
        "\n",
        "        ax8 = fig.add_subplot(gs[3, :])\n",
        "        success_count = len(successful_results)\n",
        "        failure_count = len(self.results) - success_count\n",
        "\n",
        "        categories = ['Successful', 'Failed']\n",
        "        values = [success_count, failure_count]\n",
        "        colors = ['lightgreen', 'lightcoral']\n",
        "\n",
        "        bars = ax8.bar(categories, values, color=colors, alpha=0.7)\n",
        "        ax8.set_title('📊 Evaluation Success Rate & Error Analysis', fontweight='bold')\n",
        "        ax8.set_ylabel('Count')\n",
        "\n",
        "        for bar, value in zip(bars, values):\n",
        "            ax8.text(bar.get_x() + bar.get_width()/2, bar.get_height() + max(values)*0.01,\n",
        "                    f'{value}\\n({value/len(self.results)*100:.1f}%)',\n",
        "                    ha='center', va='bottom', fontweight='bold')\n",
        "\n",
        "        plt.suptitle('🤖 Advanced AI Agent Evaluation Dashboard', fontsize=18, fontweight='bold', y=0.98)\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "        report = self.generate_advanced_report()\n",
        "        print(\"\\n\" + \"=\"*80)\n",
        "        print(\"📋 EXECUTIVE SUMMARY\")\n",
        "        print(\"=\"*80)\n",
        "        for key, value in report['executive_summary'].items():\n",
        "            if isinstance(value, float):\n",
        "                if 'rate' in key or 'performance' in key:\n",
        "                    print(f\"{key.replace('_', ' ').title()}: {value:.3%}\" if value <= 1 else f\"{key.replace('_', ' ').title()}: {value:.4f}\")\n",
        "                else:\n",
        "                    print(f\"{key.replace('_', ' ').title()}: {value:.4f}\")\n",
        "            else:\n",
        "                print(f\"{key.replace('_', ' ').title()}: {value}\")\n",
        "\n",
        "        if report['recommendations']:\n",
        "            print(f\"\\n🎯 KEY RECOMMENDATIONS:\")\n",
        "            for rec in report['recommendations'][:5]:\n",
        "                print(f\"  {rec}\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def advanced_example_agent(input_text: str) -> str:\n",
        "    \"\"\"Advanced example agent with realistic behavior patterns\"\"\"\n",
        "    responses = {\n",
        "        \"ai\": \"Artificial Intelligence is a field of computer science focused on creating systems that can perform tasks typically requiring human intelligence.\",\n",
        "        \"machine learning\": \"Machine learning is a subset of AI that enables systems to learn and improve from experience without being explicitly programmed.\",\n",
        "        \"ethics\": \"AI ethics involves ensuring AI systems are developed and deployed responsibly, considering fairness, transparency, and societal impact.\"\n",
        "    }\n",
        "\n",
        "    key = next((k for k in responses.keys() if k in input_text.lower()), None)\n",
        "    if key:\n",
        "        return responses[key] + f\" This response was generated based on the input: '{input_text}'\"\n",
        "\n",
        "    return f\"I understand you're asking about '{input_text}'. This is a complex topic that requires careful consideration of multiple factors.\"\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    evaluator = AdvancedAIEvaluator(advanced_example_agent)\n",
        "\n",
        "    test_cases = [\n",
        "        {\"input\": \"What is AI?\", \"expected\": \"AI definition with technical accuracy\", \"context\": \"Computer science context\", \"priority\": 2.0},\n",
        "        {\"input\": \"Explain machine learning ethics\", \"expected\": \"Comprehensive ethics discussion\", \"priority\": 1.5},\n",
        "        {\"input\": \"How does bias affect AI?\", \"expected\": \"Bias analysis in AI systems\", \"priority\": 2.0}\n",
        "    ]\n",
        "\n",
        "    report = evaluator.batch_evaluate(test_cases)\n",
        "    evaluator.visualize_advanced_results()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "8PGZUaBdvNNJ",
        "outputId": "9c8fa73a-40cd-4226-d29c-e438daf86774"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "✅ Advanced evaluation models initialized\n",
            "🚀 Starting advanced evaluation of 3 test cases...\n",
            "✅ Completed 1/3 evaluations\r✅ Completed 2/3 evaluations\r✅ Completed 3/3 evaluations\r\n",
            "🎉 Evaluation complete! Generated comprehensive analysis.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 2000x1500 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "================================================================================\n",
            "📋 EXECUTIVE SUMMARY\n",
            "================================================================================\n",
            "Total Evaluations: 3\n",
            "Success Rate: 100.000%\n",
            "Overall Performance: 53.340%\n",
            "Performance Std: 3.401%\n",
            "Total Cost: 0.0019\n",
            "Avg Latency: 0.0000\n",
            "Total Tokens: 96\n",
            "\n",
            "🎯 KEY RECOMMENDATIONS:\n",
            "  ⚠️ Warning: Enhance semantic similarity (current: 0.762)\n",
            "  ⚠️ Warning: Enhance hallucination score (current: 0.667)\n",
            "  🚨 Critical: Improve factual accuracy (current: 0.222)\n",
            "  🚨 Critical: Improve reasoning quality (current: 0.000)\n",
            "  ⚠️ Warning: Enhance response relevance (current: 0.758)\n"
          ]
        }
      ]
    }
  ]
}